ModeShape 3 has changed quite significantly since the 2.x releases:

• Use of Infinispan for all caching and storage - This gives a powerful and flexible foundation for creating JCR repositories that are fast, scalable, and highly available. Infinispan offers several storage options (via cache loaders), but can also be used as a distributed, multi-site, in-memory data grid.

• Improved performance - ModeShape 3 is faster than 2.x - most operations are at least one if not several orders of magnitude faster. We will publish performance and benchmarking results closer to the final release.

• Improved scalability - ModeShape 3 has been designed to store and access the content so that a node can have hundreds of thousands of child nodes (even with same-name-siblings) yet still be incredibly fast. Additionally, repositories can scale to millions of nodes and be deployed across many processes.

• Improved configuration - There is no more global configuration of the engine; instead, each repository is configured with a separate JSON file, which must conform to a JSON Schema and can be validated by ModeShape prior to use. Repository configurations can even be changed while the repository is running (some restrictions apply), making it possible to add/change/remove sequencers, authorization providers, and many other configuration options while the repository is in use.

• Runtime management - Each repository can be deployed, started, stopped, and undeployed while the engine and other repositories are still in use.

• Deployment to JBoss AS7 - Our AS7 kit installs ModeShape as an AS7 service, allowing you to configure and manage repositories using the AS7 tooling. Infinispan and JGroups are also a built-in services in AS7 that can be managed the same way. Plus, ModeShape clustering will work out of the box using AS7's built-in clustering (domain management) mechanism. ModeShape and JBoss AS7 will be the easiest way to deploy, manage and operate enterprise-grade repositories. See this page for details on how to install, configure and use.

• Storage options - ModeShape continues to have great options for where it can store content. Although ModeShape 2 had its own connector framework, ModeShape 3 simply uses Infinispan's cache loaders with out-of-the-box support for storing content in:

  • In-memory (no cache loader)

  • BerkleyDB

  • Relational databases (via JDBC), including in-memory, disk-based, or remote

  • File system

  • Cassandra

  • Cloud storage (e.g., Amazon's S3, Rackspace's Cloudfiles, or any other provider supported by JClouds)

  • Remote Infinispan

• JTA support - Clients (including EJBs) can use JCR Sessions within JTA transactions.

• Visibility of changes - Sessions now immediately see all changes persisted/committed by other sessions, although transient changes of the session always take precedence. When combined with the new way node content is being stored it should reduce the potential for conflicts during session save operations. This means that all of the Sessions using a given workspace can share the cache of persisted content, resulting in faster performance. It also significantly reduces the overhead of each session, which means ModeShape can handle more sessions.

• Thread-safety - The JCR specification only requires that the Repository and RepositoryFactory interfaces are thread-safe. ModeShape's implementation of many of the other interfaces, especially Session, Workspace, NodeTypeManager, etc., are all thread-safe. This means that it is possible for multiple threads to share one Session for reading; note that Session is inherently stateful, so sharing a Session for writes is not recommended.

• New monitoring API that allows accessing the history for over a dozen metrics using a variety of windows and durations.

• JCR-based sequencing API - sequencers now use the JCR API to access the content being processed and to create/update the derived content. Sequencers can also dynamically register namespaces and node types. This simplifies the process for creating custom sequencers. We've already migrated most of our 2.x sequencers to this new API, and will be migrating the rest over the next few weeks.

• MIME type detector API - A simple API for implementing custom MIME type detectors. (Most of the time, ModeShape's built-in detectors are sufficient.)

• Text extractor API - A simple API for implementing custom code to extract searchable text from binary values. ModeShape provides extractors for several MIME types, via the Tika library, but custom extractors can be implemented by wrapping the code that parses the binary formats.

• Improved Binary storage - A new facility was added to store binary values of all sizes, including those that are larger than available memory (e.g., gigabytes). An optimization to store small binary values with the rest of the content is available. We've started out with a file system store that will work even in clustered environments, but we also plan to add stores that use Infinispan and DBMSes.

• Deprecated APIs - A few API interfaces and methods were deprecated in 2.7.0.Final, and these have been removed. Most of ModeShape's small public API remains the same or has only backward-compatible changes.

• Bug Fixes - Of course, we've incorporated quite a few bug fixes and other minor improvements, too.

We've been planning on adding support for some other features not outlined in the JCR API, but these are likely going to be pushed to 3.1:

• Federation - Access and manipulate data from other external systems as if it were within the repository.

• Map-Reduce - Use map-reduce operations to perform reporting and custom read-only operations in parallel against the entire content of a repository. ModeShape will use this to enable validation of repository content against the current set or a proposed set of node types, as well as optimizing the storage format/layout of each node.